package org.convallaria.system.biz.util;

import org.convallaria.framework.common.constants.sys.TenantConstants;
import org.convallaria.system.biz.entity.SysTenant;

import java.time.LocalDateTime;

/**
 * 系统租户工具类
 * 
 * 功能特性：
 * - 提供租户相关的业务逻辑判断方法
 * - 提供租户状态等描述信息
 * - 提供租户数据验证方法
 * - 提供租户信息格式化方法
 * 
 * 设计原则：
 * - 纯静态方法，无状态
 * - 业务逻辑与实体类分离
 * - 便于单元测试
 * - 提高代码可维护性
 * 
 * @author convallaria
 * @since 1.0.0
 */
public class SysTenantUtils {

    // ==================== 状态判断方法 ====================

    /**
     * 判断租户是否正常状态
     * 
     * @param tenant 租户对象
     * @return true=正常，false=停用
     */
    public static boolean isNormal(SysTenant tenant) {
        if (tenant == null || tenant.getStatus() == null) {
            return false;
        }
        return TenantConstants.TENANT_STATUS_NORMAL.equals(tenant.getStatus());
    }

    /**
     * 判断租户是否停用状态
     * 
     * @param tenant 租户对象
     * @return true=停用，false=正常
     */
    public static boolean isDisabled(SysTenant tenant) {
        if (tenant == null || tenant.getStatus() == null) {
            return false;
        }
        return TenantConstants.TENANT_STATUS_DISABLED.equals(tenant.getStatus());
    }

    /**
     * 判断租户状态是否有效
     * 
     * @param status 状态值
     * @return true=有效，false=无效
     */
    public static boolean isValidStatus(String status) {
        return TenantConstants.isValidTenantStatus(status);
    }

    // ==================== 过期时间判断方法 ====================

    /**
     * 判断租户是否过期
     * 
     * @param tenant 租户对象
     * @return true=已过期，false=未过期
     */
    public static boolean isExpired(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        return TenantConstants.isTenantExpired(tenant.getExpireTime());
    }

    /**
     * 判断租户是否即将过期（30天内）
     * 
     * @param tenant 租户对象
     * @return true=即将过期，false=未即将过期
     */
    public static boolean isExpiringSoon(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        return TenantConstants.isTenantExpiringSoon(tenant.getExpireTime());
    }

    /**
     * 判断租户是否永不过期
     * 
     * @param tenant 租户对象
     * @return true=永不过期，false=有过期时间
     */
    public static boolean isNeverExpire(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        return tenant.getExpireTime() == null;
    }

    // ==================== 数据验证方法 ====================

    /**
     * 验证租户信息是否完整
     * 
     * @param tenant 租户对象
     * @return true=完整，false=不完整
     */
    public static boolean isValidTenant(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        
        // 必填字段验证
        if (!TenantConstants.isValidTenantName(tenant.getTenantName())) {
            return false;
        }
        
        // 状态验证
        if (!isValidStatus(tenant.getStatus())) {
            return false;
        }
        
        // 联系信息验证
        if (tenant.getContactUserName() != null && !TenantConstants.isValidContactUserName(tenant.getContactUserName())) {
            return false;
        }
        if (tenant.getContactPhone() != null && !TenantConstants.isValidContactPhone(tenant.getContactPhone())) {
            return false;
        }
        if (tenant.getContactEmail() != null && !TenantConstants.isValidContactEmail(tenant.getContactEmail())) {
            return false;
        }
        
        // 域名验证
        if (tenant.getDomain() != null && !TenantConstants.isValidDomain(tenant.getDomain())) {
            return false;
        }
        
        return true;
    }

    /**
     * 验证租户名称格式
     * 
     * @param tenantName 租户名称
     * @return true=有效，false=无效
     */
    public static boolean isValidTenantName(String tenantName) {
        return TenantConstants.isValidTenantName(tenantName);
    }

    /**
     * 验证联系人格式
     * 
     * @param contactUserName 联系人
     * @return true=有效，false=无效
     */
    public static boolean isValidContactUserName(String contactUserName) {
        return TenantConstants.isValidContactUserName(contactUserName);
    }

    /**
     * 验证联系电话格式
     * 
     * @param contactPhone 联系电话
     * @return true=有效，false=无效
     */
    public static boolean isValidContactPhone(String contactPhone) {
        return TenantConstants.isValidContactPhone(contactPhone);
    }

    /**
     * 验证联系邮箱格式
     * 
     * @param contactEmail 联系邮箱
     * @return true=有效，false=无效
     */
    public static boolean isValidContactEmail(String contactEmail) {
        return TenantConstants.isValidContactEmail(contactEmail);
    }

    /**
     * 验证域名格式
     * 
     * @param domain 域名
     * @return true=有效，false=无效
     */
    public static boolean isValidDomain(String domain) {
        return TenantConstants.isValidDomain(domain);
    }

    // ==================== 格式化方法 ====================

    /**
     * 格式化租户显示名称
     * 
     * @param tenant 租户对象
     * @return 格式化后的显示名称
     */
    public static String formatDisplayName(SysTenant tenant) {
        if (tenant == null) {
            return "未知租户";
        }
        
        String displayName = tenant.getTenantName();
        if (displayName == null || displayName.trim().isEmpty()) {
            return "未知租户";
        }
        
        return displayName;
    }

    /**
     * 格式化租户完整信息
     * 
     * @param tenant 租户对象
     * @return 格式化后的完整信息
     */
    public static String formatTenantInfo(SysTenant tenant) {
        if (tenant == null) {
            return "租户信息为空";
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append("租户ID: ").append(tenant.getTenantId()).append(", ");
        sb.append("租户名称: ").append(tenant.getTenantName()).append(", ");
        sb.append("状态: ").append(getStatusDesc(tenant.getStatus())).append(", ");
        sb.append("联系人: ").append(tenant.getContactUserName()).append(", ");
        sb.append("联系电话: ").append(tenant.getContactPhone());
        
        return sb.toString();
    }

    /**
     * 格式化租户过期信息
     * 
     * @param tenant 租户对象
     * @return 格式化后的过期信息
     */
    public static String formatExpireInfo(SysTenant tenant) {
        if (tenant == null) {
            return "租户信息为空";
        }
        
        if (isNeverExpire(tenant)) {
            return "永不过期";
        }
        
        if (isExpired(tenant)) {
            return "已过期";
        }
        
        if (isExpiringSoon(tenant)) {
            return "即将过期";
        }
        
        return "正常";
    }

    // ==================== 描述信息方法 ====================

    /**
     * 获取租户状态描述
     * 
     * @param status 状态值
     * @return 状态描述
     */
    public static String getStatusDesc(String status) {
        return TenantConstants.getTenantStatusDesc(status);
    }

    /**
     * 获取租户过期状态描述
     * 
     * @param tenant 租户对象
     * @return 过期状态描述
     */
    public static String getExpireStatusDesc(SysTenant tenant) {
        if (tenant == null) {
            return "未知";
        }
        
        if (isNeverExpire(tenant)) {
            return "永不过期";
        }
        
        if (isExpired(tenant)) {
            return "已过期";
        }
        
        if (isExpiringSoon(tenant)) {
            return "即将过期";
        }
        
        return "正常";
    }

    // ==================== 业务逻辑方法 ====================

    /**
     * 判断租户是否可以删除
     * 
     * @param tenant 租户对象
     * @return true=可以删除，false=不能删除
     */
    public static boolean canDelete(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        
        // 系统租户不能删除
        if (TenantConstants.DEFAULT_TENANT_ID.equals(tenant.getTenantId())) {
            return false;
        }
        
        // 停用的租户可以删除
        return isDisabled(tenant);
    }

    /**
     * 判断租户是否可以编辑
     * 
     * @param tenant 租户对象
     * @return true=可以编辑，false=不能编辑
     */
    public static boolean canEdit(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        
        // 所有租户都可以编辑
        return true;
    }

    /**
     * 判断租户是否可以使用
     * 
     * @param tenant 租户对象
     * @return true=可以使用，false=不能使用
     */
    public static boolean canUse(SysTenant tenant) {
        if (tenant == null) {
            return false;
        }
        
        // 正常状态且未过期的租户可以使用
        return isNormal(tenant) && !isExpired(tenant);
    }

    /**
     * 判断租户是否为空
     * 
     * @param tenant 租户对象
     * @return true=为空，false=不为空
     */
    public static boolean isEmpty(SysTenant tenant) {
        if (tenant == null) {
            return true;
        }
        
        return (tenant.getTenantName() == null || tenant.getTenantName().trim().isEmpty());
    }

    /**
     * 判断租户是否有效（非空且状态正常且未过期）
     * 
     * @param tenant 租户对象
     * @return true=有效，false=无效
     */
    public static boolean isValid(SysTenant tenant) {
        return !isEmpty(tenant) && isNormal(tenant) && !isExpired(tenant);
    }

    /**
     * 判断租户名称是否重复
     * 
     * @param tenant1 租户对象1
     * @param tenant2 租户对象2
     * @return true=重复，false=不重复
     */
    public static boolean isTenantNameDuplicate(SysTenant tenant1, SysTenant tenant2) {
        if (tenant1 == null || tenant2 == null) {
            return false;
        }
        
        String name1 = tenant1.getTenantName();
        String name2 = tenant2.getTenantName();
        
        if (name1 == null || name2 == null) {
            return false;
        }
        
        return name1.equals(name2);
    }

    /**
     * 判断域名是否重复
     * 
     * @param tenant1 租户对象1
     * @param tenant2 租户对象2
     * @return true=重复，false=不重复
     */
    public static boolean isDomainDuplicate(SysTenant tenant1, SysTenant tenant2) {
        if (tenant1 == null || tenant2 == null) {
            return false;
        }
        
        String domain1 = tenant1.getDomain();
        String domain2 = tenant2.getDomain();
        
        if (domain1 == null || domain2 == null) {
            return false;
        }
        
        return domain1.equals(domain2);
    }

    /**
     * 清理租户名称（去除多余空格）
     * 
     * @param tenant 租户对象
     * @return 清理后的租户名称
     */
    public static String cleanTenantName(SysTenant tenant) {
        if (tenant == null || tenant.getTenantName() == null) {
            return "";
        }
        return TenantConstants.cleanTenantName(tenant.getTenantName());
    }

    /**
     * 清理联系人（去除多余空格）
     * 
     * @param tenant 租户对象
     * @return 清理后的联系人
     */
    public static String cleanContactUserName(SysTenant tenant) {
        if (tenant == null || tenant.getContactUserName() == null) {
            return "";
        }
        return TenantConstants.cleanContactUserName(tenant.getContactUserName());
    }

    /**
     * 清理联系电话（去除多余空格和特殊字符）
     * 
     * @param tenant 租户对象
     * @return 清理后的联系电话
     */
    public static String cleanContactPhone(SysTenant tenant) {
        if (tenant == null || tenant.getContactPhone() == null) {
            return "";
        }
        return TenantConstants.cleanContactPhone(tenant.getContactPhone());
    }

    /**
     * 清理域名（转换为小写）
     * 
     * @param tenant 租户对象
     * @return 清理后的域名
     */
    public static String cleanDomain(SysTenant tenant) {
        if (tenant == null || tenant.getDomain() == null) {
            return "";
        }
        return TenantConstants.cleanDomain(tenant.getDomain());
    }

    /**
     * 获取租户剩余天数
     * 
     * @param tenant 租户对象
     * @return 剩余天数，-1表示永不过期，-2表示已过期
     */
    public static long getRemainingDays(SysTenant tenant) {
        if (tenant == null || tenant.getExpireTime() == null) {
            return -1; // 永不过期
        }
        
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime expireTime = tenant.getExpireTime();
        
        if (now.isAfter(expireTime)) {
            return -2; // 已过期
        }
        
        return java.time.Duration.between(now, expireTime).toDays();
    }
}
